تسلط بر همزمانی: نگاهی عمیق به همگام‌سازی مبتنی بر قفل

یک آشپزخانه حرفه‌ای و شلوغ را تصور کنید. چندین سرآشپز به طور همزمان کار می‌کنند و همه به یک انبار مشترک مواد اولیه نیاز دارند. اگر دو سرآشپز دقیقاً در یک لحظه سعی کنند آخرین شیشه یک ادویه کمیاب را بردارند، چه کسی آن را به دست می‌آورد؟ چه می‌شود اگر یک سرآشپز در حال به‌روزرسانی کارت دستور پخت باشد در حالی که دیگری در حال خواندن آن است و این منجر به یک دستورالعمل نیمه‌کاره و بی‌معنی شود؟ این هرج‌ومرج آشپزخانه یک تشبیه عالی برای چالش اصلی در توسعه نرم‌افزار مدرن است: همزمانی (concurrency).

در دنیای امروز پردازنده‌های چند هسته‌ای، سیستم‌های توزیع‌شده و برنامه‌های کاربردی با پاسخ‌دهی بالا، همزمانی—توانایی اجرای بخش‌های مختلف یک برنامه خارج از ترتیب یا با ترتیب جزئی بدون تأثیر بر نتیجه نهایی—یک قابلیت لوکس نیست؛ بلکه یک ضرورت است. این همان موتوری است که در پشت سرورهای وب سریع، رابط‌های کاربری روان و خطوط لوله پردازش داده قدرتمند قرار دارد. با این حال، این قدرت با پیچیدگی قابل توجهی همراه است. هنگامی که چندین نخ یا فرآیند به طور همزمان به منابع مشترک دسترسی پیدا می‌کنند، می‌توانند با یکدیگر تداخل داشته باشند و منجر به خرابی داده‌ها، رفتار غیرقابل پیش‌بینی و از کار افتادن سیستم‌های حیاتی شوند. اینجاست که کنترل همزمانی (concurrency control) وارد عمل می‌شود.

این راهنمای جامع، اساسی‌ترین و پرکاربردترین تکنیک برای مدیریت این هرج‌ومرج کنترل‌شده را بررسی خواهد کرد: همگام‌سازی مبتنی بر قفل (lock-based synchronization). ما ابهام‌زدایی خواهیم کرد که قفل‌ها چه هستند، اشکال مختلف آنها را بررسی می‌کنیم، در دام‌های خطرناک آنها پیمایش می‌کنیم و مجموعه‌ای از بهترین شیوه‌های جهانی را برای نوشتن کد همزمان قوی، ایمن و کارآمد ایجاد می‌کنیم.

کنترل همزمانی چیست؟

در هسته خود، کنترل همزمانی رشته‌ای در علوم کامپیوتر است که به مدیریت عملیات همزمان روی داده‌های مشترک اختصاص دارد. هدف اصلی آن اطمینان از اجرای صحیح عملیات همزمان بدون تداخل با یکدیگر، و حفظ یکپارچگی و سازگاری داده‌ها است. آن را مانند مدیر آشپزخانه‌ای در نظر بگیرید که قوانینی برای نحوه دسترسی سرآشپزها به انبار تعیین می‌کند تا از ریخت‌وپاش، اشتباه و هدر رفتن مواد اولیه جلوگیری کند.

در دنیای پایگاه‌های داده، کنترل همزمانی برای حفظ ویژگی‌های ACID (اتمی بودن، سازگاری، جداسازی، پایایی)، به ویژه جداسازی (Isolation)، ضروری است. جداسازی تضمین می‌کند که اجرای همزمان تراکنش‌ها منجر به حالتی از سیستم می‌شود که اگر تراکنش‌ها به صورت سریالی، یکی پس از دیگری، اجرا می‌شدند، به دست می‌آمد.

دو فلسفه اصلی برای پیاده‌سازی کنترل همزمانی وجود دارد:

• کنترل همزمانی خوش‌بینانه: این رویکرد فرض می‌کند که تداخل‌ها نادر هستند. این رویکرد به عملیات اجازه می‌دهد بدون هیچ بررسی اولیه‌ای ادامه یابند. قبل از ثبت نهایی یک تغییر، سیستم بررسی می‌کند که آیا عملیات دیگری در این فاصله داده‌ها را تغییر داده است یا خیر. اگر تداخلی شناسایی شود، عملیات معمولاً بازگردانده شده و دوباره امتحان می‌شود. این یک استراتژی «اول انجام بده، بعداً اجازه بگیر» است.
• کنترل همزمانی بدبینانه: این رویکرد فرض می‌کند که تداخل‌ها محتمل هستند. این رویکرد یک عملیات را مجبور می‌کند تا قبل از دسترسی به یک منبع، قفلی روی آن به دست آورد و از تداخل سایر عملیات جلوگیری می‌کند. این یک استراتژی «اول اجازه بگیر، بعداً انجام بده» است.

این مقاله منحصراً بر رویکرد بدبینانه تمرکز دارد که پایه و اساس همگام‌سازی مبتنی بر قفل است.

مشکل اصلی: وضعیت‌های رقابتی (Race Conditions)

قبل از اینکه بتوانیم راه‌حل را درک کنیم، باید مشکل را به طور کامل بشناسیم. رایج‌ترین و موذیانه‌ترین باگ در برنامه‌نویسی همزمان، وضعیت رقابتی (race condition) است. یک وضعیت رقابتی زمانی رخ می‌دهد که رفتار یک سیستم به توالی یا زمان‌بندی غیرقابل پیش‌بینی رویدادهای غیرقابل کنترل، مانند زمان‌بندی نخ‌ها توسط سیستم عامل، بستگی داشته باشد.

بیایید مثال کلاسیک را در نظر بگیریم: یک حساب بانکی مشترک. فرض کنید یک حساب ۱۰۰۰ دلار موجودی دارد و دو نخ همزمان سعی می‌کنند هر کدام ۱۰۰ دلار واریز کنند.

در اینجا یک توالی ساده‌شده از عملیات برای واریز وجه آمده است:

1. خواندن موجودی فعلی از حافظه.
2. افزودن مبلغ واریزی به این مقدار.
3. نوشتن مقدار جدید در حافظه.

یک اجرای صحیح و سریالی منجر به موجودی نهایی ۱۲۰۰ دلار می‌شود. اما در یک سناریوی همزمان چه اتفاقی می‌افتد؟

یک درهم‌آمیزی محتمل از عملیات:

• نخ A: موجودی را می‌خواند (۱۰۰۰ دلار).
• تعویض زمینه (Context Switch): سیستم عامل نخ A را متوقف کرده و نخ B را اجرا می‌کند.
• نخ B: موجودی را می‌خواند (همچنان ۱۰۰۰ دلار).
• نخ B: موجودی جدید خود را محاسبه می‌کند (۱۰۰۰ دلار + ۱۰۰ دلار = ۱۱۰۰ دلار).
• نخ B: موجودی جدید (۱۱۰۰ دلار) را در حافظه می‌نویسد.
• تعویض زمینه (Context Switch): سیستم عامل نخ A را از سر می‌گیرد.
• نخ A: موجودی جدید خود را بر اساس مقداری که قبلاً خوانده بود محاسبه می‌کند (۱۰۰۰ دلار + ۱۰۰ دلار = ۱۱۰۰ دلار).
• نخ A: موجودی جدید (۱۱۰۰ دلار) را در حافظه می‌نویسد.

موجودی نهایی ۱۱۰۰ دلار است، نه ۱۲۰۰ دلار مورد انتظار. یک واریز ۱۰۰ دلاری به دلیل وضعیت رقابتی در هوا ناپدید شده است. بلوک کدی که در آن منبع مشترک (موجودی حساب) مورد دسترسی قرار می‌گیرد، به عنوان بخش بحرانی (critical section) شناخته می‌شود. برای جلوگیری از وضعیت‌های رقابتی، باید اطمینان حاصل کنیم که در هر زمان فقط یک نخ می‌تواند در بخش بحرانی اجرا شود. این اصل انحصار متقابل (mutual exclusion) نامیده می‌شود.

معرفی همگام‌سازی مبتنی بر قفل

همگام‌سازی مبتنی بر قفل، مکانیزم اصلی برای اعمال انحصار متقابل است. یک قفل (که به آن میوتکس نیز گفته می‌شود) یک ابزار اولیه همگام‌سازی است که به عنوان یک نگهبان برای بخش بحرانی عمل می‌کند.

تشبیه کلید یک سرویس بهداشتی تک‌نفره بسیار مناسب است. سرویس بهداشتی بخش بحرانی است و کلید، قفل است. افراد زیادی (نخ‌ها) ممکن است بیرون منتظر باشند، اما فقط فردی که کلید را در دست دارد می‌تواند وارد شود. وقتی کارشان تمام شد، خارج شده و کلید را برمی‌گردانند و به نفر بعدی در صف اجازه می‌دهند تا آن را برداشته و وارد شود.

قفل‌ها از دو عملیات اساسی پشتیبانی می‌کنند:

• دریافت (Acquire یا Lock): یک نخ قبل از ورود به بخش بحرانی این عملیات را فراخوانی می‌کند. اگر قفل در دسترس باشد، نخ آن را دریافت کرده و ادامه می‌دهد. اگر قفل قبلاً توسط نخ دیگری نگه داشته شده باشد، نخ فراخواننده مسدود (یا "خواب") می‌شود تا زمانی که قفل آزاد شود.
• آزاد کردن (Release یا Unlock): یک نخ پس از اتمام اجرای بخش بحرانی، این عملیات را فراخوانی می‌کند. این کار قفل را برای دریافت توسط سایر نخ‌های منتظر، در دسترس قرار می‌دهد.

با پیچیدن منطق حساب بانکی خود در یک قفل، می‌توانیم صحت آن را تضمین کنیم:

acquire_lock(account_lock); // --- شروع بخش بحرانی --- balance = read_balance(); new_balance = balance + amount; write_balance(new_balance); // --- پایان بخش بحرانی --- release_lock(account_lock);

اکنون، اگر نخ A ابتدا قفل را به دست آورد، نخ B مجبور خواهد شد تا زمانی که نخ A هر سه مرحله را تکمیل کرده و قفل را آزاد کند، منتظر بماند. عملیات دیگر در هم آمیخته نمی‌شوند و وضعیت رقابتی از بین می‌رود.

انواع قفل‌ها: جعبه ابزار برنامه‌نویس

در حالی که مفهوم اساسی قفل ساده است، سناریوهای مختلف نیازمند انواع متفاوتی از مکانیزم‌های قفل‌گذاری هستند. درک جعبه ابزار قفل‌های موجود برای ساختن سیستم‌های همزمان کارآمد و صحیح، حیاتی است.

قفل‌های میوتکس (انحصار متقابل)

میوتکس ساده‌ترین و رایج‌ترین نوع قفل است. این یک قفل باینری است، به این معنی که فقط دو حالت دارد: قفل شده یا باز. این قفل برای اعمال انحصار متقابل سخت‌گیرانه طراحی شده است و تضمین می‌کند که در هر زمان فقط یک نخ می‌تواند مالک قفل باشد.

• مالکیت: یکی از ویژگی‌های کلیدی اکثر پیاده‌سازی‌های میوتکس، مالکیت است. نخی که میوتکس را به دست می‌آورد، تنها نخی است که مجاز به آزاد کردن آن است. این کار از باز کردن ناخواسته (یا مخرب) یک بخش بحرانی توسط نخ دیگر جلوگیری می‌کند.
• کاربرد: میوتکس‌ها انتخاب پیش‌فرض برای محافظت از بخش‌های بحرانی کوتاه و ساده، مانند به‌روزرسانی یک متغیر مشترک یا تغییر یک ساختار داده، هستند.

سمافورها (Semaphores)

سمافور یک ابزار همگام‌سازی عمومی‌تر است که توسط دانشمند کامپیوتر هلندی، ادسخر دایکسترا، ابداع شد. برخلاف میوتکس، سمافور یک شمارنده با مقدار صحیح غیرمنفی را نگهداری می‌کند.

این ابزار از دو عملیات اتمی پشتیبانی می‌کند:

• wait() (یا عملیات P): شمارنده سمافور را کاهش می‌دهد. اگر شمارنده منفی شود، نخ مسدود می‌شود تا زمانی که شمارنده بزرگتر یا مساوی صفر شود.
• signal() (یا عملیات V): شمارنده سمافور را افزایش می‌دهد. اگر نخی روی سمافور مسدود شده باشد، یکی از آنها از حالت انسداد خارج می‌شود.

دو نوع اصلی سمافور وجود دارد:

• سمافور باینری: شمارنده با مقدار ۱ مقداردهی اولیه می‌شود. این شمارنده فقط می‌تواند ۰ یا ۱ باشد، که آن را از نظر عملکردی معادل یک میوتکس می‌کند.
• سمافور شمارشی: شمارنده می‌تواند با هر عدد صحیح N > 1 مقداردهی اولیه شود. این کار به N نخ اجازه می‌دهد تا به طور همزمان به یک منبع دسترسی داشته باشند. از این نوع سمافور برای کنترل دسترسی به یک مجموعه محدود از منابع استفاده می‌شود.

مثال: یک برنامه وب را با یک استخر اتصال (connection pool) تصور کنید که می‌تواند حداکثر ۱۰ اتصال همزمان به پایگاه داده را مدیریت کند. یک سمافور شمارشی که با ۱۰ مقداردهی اولیه شده، می‌تواند این کار را به خوبی مدیریت کند. هر نخ باید قبل از گرفتن یک اتصال، عملیات `wait()` را روی سمافور انجام دهد. نخ یازدهم مسدود خواهد شد تا زمانی که یکی از ۱۰ نخ اول کار خود با پایگاه داده را تمام کرده و عملیات `signal()` را روی سمافور انجام دهد و اتصال را به استخر بازگرداند.

قفل‌های خواندن-نوشتن (قفل‌های اشتراکی/انحصاری)

یک الگوی رایج در سیستم‌های همزمان این است که داده‌ها بسیار بیشتر از آنچه نوشته می‌شوند، خوانده می‌شوند. استفاده از یک میوتکس ساده در این سناریو ناکارآمد است، زیرا مانع از خواندن همزمان داده‌ها توسط چندین نخ می‌شود، حتی اگر خواندن یک عملیات ایمن و بدون تغییر باشد.

یک قفل خواندن-نوشتن (Read-Write Lock) با ارائه دو حالت قفل‌گذاری این مشکل را حل می‌کند:

• قفل اشتراکی (خواندن): چندین نخ می‌توانند به طور همزمان یک قفل خواندن را به دست آورند، تا زمانی که هیچ نخی قفل نوشتن را در اختیار نداشته باشد. این امر امکان خواندن با همزمانی بالا را فراهم می‌کند.
• قفل انحصاری (نوشتن): در هر زمان فقط یک نخ می‌تواند قفل نوشتن را به دست آورد. هنگامی که یک نخ قفل نوشتن را در اختیار دارد، تمام نخ‌های دیگر (چه خواننده و چه نویسنده) مسدود می‌شوند.

تشبیه آن مانند سندی در یک کتابخانه مشترک است. افراد زیادی می‌توانند همزمان نسخه‌هایی از سند را بخوانند (قفل خواندن اشتراکی). اما اگر کسی بخواهد سند را ویرایش کند، باید آن را به صورت انحصاری به امانت بگیرد و هیچ کس دیگری نمی‌تواند تا پایان کار او، آن را بخواند یا ویرایش کند (قفل نوشتن انحصاری).

قفل‌های بازگشتی (Reentrant Locks)

چه اتفاقی می‌افتد اگر نخی که قبلاً یک میوتکس را در اختیار دارد، دوباره سعی کند آن را به دست آورد؟ با یک میوتکس استاندارد، این امر منجر به بن‌بست فوری می‌شود—نخ برای همیشه منتظر می‌ماند تا خودش قفل را آزاد کند. یک قفل بازگشتی (Recursive Lock یا Reentrant Lock) برای حل این مشکل طراحی شده است.

یک قفل بازگشتی به همان نخ اجازه می‌دهد تا همان قفل را چندین بار به دست آورد. این قفل یک شمارنده مالکیت داخلی را نگهداری می‌کند. قفل تنها زمانی به طور کامل آزاد می‌شود که نخ مالک، به همان تعدادی که `acquire()` را فراخوانی کرده، `release()` را نیز فراخوانی کند. این ویژگی به ویژه در توابع بازگشتی که نیاز به محافظت از یک منبع مشترک در طول اجرای خود دارند، مفید است.

خطرات قفل‌گذاری: دام‌های رایج

در حالی که قفل‌ها قدرتمند هستند، اما یک شمشیر دولبه‌اند. استفاده نادرست از قفل‌ها می‌تواند منجر به باگ‌هایی شود که تشخیص و رفع آنها بسیار دشوارتر از وضعیت‌های رقابتی ساده است. این مشکلات شامل بن‌بست‌ها (deadlocks)، قفل‌های زنده (livelocks) و تنگناهای عملکردی هستند.

بن‌بست (Deadlock)

بن‌بست ترسناک‌ترین سناریو در برنامه‌نویسی همزمان است. این اتفاق زمانی رخ می‌دهد که دو یا چند نخ به طور نامحدود مسدود می‌شوند، در حالی که هر کدام منتظر منبعی هستند که توسط نخ دیگری در همان مجموعه نگهداری می‌شود.

یک سناریوی ساده با دو نخ (نخ ۱، نخ ۲) و دو قفل (قفل A، قفل B) را در نظر بگیرید:

1. نخ ۱ قفل A را به دست می‌آورد.
2. نخ ۲ قفل B را به دست می‌آورد.
3. اکنون نخ ۱ سعی می‌کند قفل B را به دست آورد، اما این قفل در اختیار نخ ۲ است، بنابراین نخ ۱ مسدود می‌شود.
4. اکنون نخ ۲ سعی می‌کند قفل A را به دست آورد، اما این قفل در اختیار نخ ۱ است، بنابراین نخ ۲ مسدود می‌شود.

اکنون هر دو نخ در یک حالت انتظار دائمی گیر کرده‌اند. برنامه متوقف می‌شود. این وضعیت از وجود چهار شرط لازم (شرایط کافمن) ناشی می‌شود:

1. انحصار متقابل: منابع (قفل‌ها) نمی‌توانند به اشتراک گذاشته شوند.
2. نگه داشتن و انتظار: یک نخ حداقل یک منبع را در حالی که منتظر دیگری است، نگه می‌دارد.
3. عدم بازپس‌گیری: یک منبع را نمی‌توان به زور از نخی که آن را در اختیار دارد، گرفت.
4. انتظار دایره‌ای: زنجیره‌ای از دو یا چند نخ وجود دارد که در آن هر نخ منتظر منبعی است که توسط نخ بعدی در زنجیره نگهداری می‌شود.

جلوگیری از بن‌بست شامل شکستن حداقل یکی از این شرایط است. رایج‌ترین استراتژی، شکستن شرط انتظار دایره‌ای با اعمال یک ترتیب سراسری و سخت‌گیرانه برای به دست آوردن قفل‌ها است.

قفل زنده (Livelock)

قفل زنده نسخه‌ی ظریف‌تری از بن‌بست است. در یک قفل زنده، نخ‌ها مسدود نیستند—آنها فعالانه در حال اجرا هستند—اما هیچ پیشرفتی نمی‌کنند. آنها در یک حلقه از پاسخ دادن به تغییرات وضعیت یکدیگر بدون انجام هیچ کار مفیدی گیر کرده‌اند.

تشبیه کلاسیک آن دو نفری هستند که سعی می‌کنند در یک راهروی باریک از کنار هم عبور کنند. هر دو سعی می‌کنند مؤدب باشند و به سمت چپ خود قدم بردارند، اما در نهایت راه یکدیگر را مسدود می‌کنند. سپس هر دو به سمت راست خود قدم برمی‌دارند و دوباره راه هم را مسدود می‌کنند. آنها فعالانه حرکت می‌کنند اما در راهرو پیشرفتی نمی‌کنند. در نرم‌افزار، این اتفاق می‌تواند با مکانیزم‌های بازیابی بن‌بست با طراحی ضعیف رخ دهد که در آن نخ‌ها به طور مکرر عقب‌نشینی کرده و دوباره تلاش می‌کنند، اما فقط دوباره با هم تداخل پیدا می‌کنند.

گرسنگی (Starvation)

گرسنگی زمانی رخ می‌دهد که یک نخ به طور دائم از دسترسی به یک منبع ضروری محروم می‌شود، حتی اگر آن منبع در دسترس قرار گیرد. این اتفاق می‌تواند در سیستم‌هایی با الگوریتم‌های زمان‌بندی که "عادلانه" نیستند، رخ دهد. به عنوان مثال، اگر یک مکانیزم قفل‌گذاری همیشه به نخ‌های با اولویت بالا دسترسی بدهد، یک نخ با اولویت پایین ممکن است هرگز فرصت اجرا پیدا نکند اگر جریانی مداوم از رقبای با اولویت بالا وجود داشته باشد.

سربار عملکردی

قفل‌ها رایگان نیستند. آنها به چندین روش سربار عملکردی ایجاد می‌کنند:

• هزینه دریافت/آزاد کردن: عمل به دست آوردن و آزاد کردن یک قفل شامل عملیات اتمی و حصارهای حافظه است که از نظر محاسباتی گران‌تر از دستورالعمل‌های عادی هستند.
• رقابت (Contention): هنگامی که چندین نخ به طور مکرر برای یک قفل رقابت می‌کنند، سیستم زمان قابل توجهی را صرف تعویض زمینه و زمان‌بندی نخ‌ها به جای انجام کار مولد می‌کند. رقابت بالا به طور مؤثری اجرا را سریالی می‌کند و هدف موازی‌سازی را از بین می‌برد.

بهترین شیوه‌ها برای همگام‌سازی مبتنی بر قفل

نوشتن کد همزمان صحیح و کارآمد با قفل‌ها نیازمند نظم و پایبندی به مجموعه‌ای از بهترین شیوه‌ها است. این اصول به طور جهانی، صرف نظر از زبان برنامه‌نویسی یا پلتفرم، قابل اجرا هستند.

۱. بخش‌های بحرانی را کوچک نگه دارید

یک قفل باید برای کوتاه‌ترین مدت ممکن نگه داشته شود. بخش بحرانی شما باید فقط شامل کدی باشد که مطلقاً باید از دسترسی همزمان محافظت شود. هرگونه عملیات غیر بحرانی (مانند ورودی/خروجی، محاسبات پیچیده‌ای که شامل وضعیت مشترک نیستند) باید خارج از منطقه قفل شده انجام شود. هرچه یک قفل را طولانی‌تر نگه دارید، احتمال رقابت بیشتر شده و نخ‌های دیگر را بیشتر مسدود می‌کنید.

۲. دانه‌بندی (Granularity) مناسب قفل را انتخاب کنید

دانه‌بندی قفل به میزان داده‌ای اشاره دارد که توسط یک قفل محافظت می‌شود.

• قفل‌گذاری درشت‌دانه: استفاده از یک قفل واحد برای محافظت از یک ساختار داده بزرگ یا یک زیرسیستم کامل. پیاده‌سازی و استدلال در مورد این روش ساده‌تر است اما می‌تواند منجر به رقابت بالا شود، زیرا عملیات نامرتبط روی بخش‌های مختلف داده همگی توسط همان قفل سریالی می‌شوند.
• قفل‌گذاری ریزدانه: استفاده از چندین قفل برای محافظت از بخش‌های مختلف و مستقل یک ساختار داده. به عنوان مثال، به جای یک قفل برای کل یک جدول هش، می‌توانید برای هر سطل (bucket) یک قفل جداگانه داشته باشید. این روش پیچیده‌تر است اما می‌تواند با اجازه دادن به موازی‌سازی واقعی بیشتر، عملکرد را به طور چشمگیری بهبود بخشد.

انتخاب بین این دو، یک بده‌بستان بین سادگی و عملکرد است. با قفل‌های درشت‌تر شروع کنید و تنها در صورتی به سمت قفل‌های ریزدانه‌تر بروید که پروفایل‌سنجی عملکرد نشان دهد که رقابت بر سر قفل یک تنگنا است.

۳. همیشه قفل‌های خود را آزاد کنید

عدم آزاد کردن یک قفل یک خطای فاجعه‌بار است که احتمالاً سیستم شما را متوقف خواهد کرد. یک منبع رایج این خطا زمانی است که یک استثنا یا یک بازگشت زودهنگام در داخل یک بخش بحرانی رخ می‌دهد. برای جلوگیری از این امر، همیشه از ساختارهای زبانی استفاده کنید که پاک‌سازی را تضمین می‌کنند، مانند بلوک‌های try...finally در جاوا یا C#، یا الگوهای RAII (Resource Acquisition Is Initialization) با قفل‌های حوزه‌بندی شده در C++.

مثال (شبه‌کد با استفاده از try-finally):

my_lock.acquire(); try { // کد بخش بحرانی که ممکن است استثنا ایجاد کند } finally { my_lock.release(); // اجرای این بخش تضمین شده است }

۴. از یک ترتیب قفل‌گذاری سخت‌گیرانه پیروی کنید

برای جلوگیری از بن‌بست، مؤثرترین استراتژی شکستن شرط انتظار دایره‌ای است. یک ترتیب سخت‌گیرانه، سراسری و قراردادی برای به دست آوردن چندین قفل ایجاد کنید. اگر یک نخ نیاز به نگه داشتن هر دو قفل A و B داشته باشد، باید همیشه قفل A را قبل از قفل B به دست آورد. این قانون ساده، انتظارهای دایره‌ای را غیرممکن می‌سازد.

۵. جایگزین‌های قفل‌گذاری را در نظر بگیرید

در حالی که قفل‌ها اساسی هستند، اما تنها راه‌حل برای کنترل همزمانی نیستند. برای سیستم‌های با کارایی بالا، ارزش دارد که تکنیک‌های پیشرفته را بررسی کنید:

• ساختارهای داده بدون قفل: اینها ساختارهای داده پیچیده‌ای هستند که با استفاده از دستورالعمل‌های سخت‌افزاری اتمی سطح پایین (مانند Compare-And-Swap) طراحی شده‌اند و امکان دسترسی همزمان را بدون استفاده از قفل فراهم می‌کنند. پیاده‌سازی صحیح آنها بسیار دشوار است اما می‌توانند عملکرد برتری را تحت رقابت بالا ارائه دهند.
• داده‌های تغییرناپذیر: اگر داده‌ها پس از ایجاد هرگز تغییر نکنند، می‌توانند آزادانه بین نخ‌ها بدون نیاز به هیچ‌گونه همگام‌سازی به اشتراک گذاشته شوند. این یک اصل اصلی برنامه‌نویسی تابعی است و روشی محبوب برای ساده‌سازی طراحی‌های همزمان است.
• حافظه تراکنشی نرم‌افزاری (STM): یک انتزاع سطح بالاتر که به توسعه‌دهندگان اجازه می‌دهد تراکنش‌های اتمی را در حافظه تعریف کنند، بسیار شبیه به پایگاه داده. سیستم STM جزئیات پیچیده همگام‌سازی را در پشت صحنه مدیریت می‌کند.

نتیجه‌گیری

همگام‌سازی مبتنی بر قفل سنگ بنای برنامه‌نویسی همزمان است. این روش یک راه قدرتمند و مستقیم برای محافظت از منابع مشترک و جلوگیری از خرابی داده‌ها فراهم می‌کند. از میوتکس ساده گرفته تا قفل خواندن-نوشتن با جزئیات بیشتر، این ابزارهای اولیه برای هر توسعه‌دهنده‌ای که برنامه‌های چندنخی می‌سازد، ضروری هستند.

با این حال، این قدرت نیازمند مسئولیت‌پذیری است. درک عمیق از دام‌های بالقوه—بن‌بست‌ها، قفل‌های زنده و کاهش عملکرد—اختیاری نیست. با پایبندی به بهترین شیوه‌ها مانند به حداقل رساندن اندازه بخش بحرانی، انتخاب دانه‌بندی مناسب قفل و اعمال یک ترتیب قفل‌گذاری سخت‌گیرانه، می‌توانید از قدرت همزمانی بهره‌مند شوید و در عین حال از خطرات آن دوری کنید.

تسلط بر همزمانی یک سفر است. این امر نیازمند طراحی دقیق، آزمایش‌های سخت‌گیرانه و ذهنیتی است که همیشه از تعاملات پیچیده‌ای که هنگام اجرای موازی نخ‌ها می‌تواند رخ دهد، آگاه باشد. با تسلط بر هنر قفل‌گذاری، شما گام مهمی در جهت ساختن نرم‌افزاری برمی‌دارید که نه تنها سریع و پاسخگو، بلکه قوی، قابل اعتماد و صحیح نیز باشد.